The present invention generally relates to the field of emulation or simulation. More particularly, the present invention relates to a method for performing more efficient input from, and output to, storage media in an emulated computing environment.
The idea of emulating an existing software execution environment on a hardware architecture other than the one it was designed for is not new. At the same time, the need for more efficient, elegant solutions to the problems typically arising in the area of emulation has never been greater. For example, the information technology departments of numerous critical industries (e.g., banking, insurance, airline) often work in enterprise server platform (e.g., mainframe) environments which typically feature proprietary technology. In many instances, these departments have developed and enhanced critical applications using such proprietary platforms over decades.
Concurrently, recent developments have revealed a trend toward industry-wide standardization of components associated with open platform type processing environments. Such open platforms typically deliver flexibility, more friendly user interfaces and generally run in a hardware environment consisting of largely commodity components. Thus, open platform systems tend to be less expensive than proprietary enterprise server platforms. Accordingly, the need for emulation of proprietary enterprise server based applications and software in a more widely used, commodity hardware architecture is burgeoning.
xe2x80x9cEmulationxe2x80x9d generally refers to the process of simulating the functionality and output of a target system application in a host system environment having an architecture which differs from that of the target system. To achieve such xe2x80x9cemulation,xe2x80x9d a translator/interpreter program(s) executable by the host system is provided which maps the instructions comprising the target system application (i.e., the application emulated) into a corresponding instruction set native to the host system.
The task of developing such a translator/interpreter is not straightforward. In particular, the instruction set native to the target system necessarily represents a set of commands resulting in processes which are architecture specific. For example, the direction in which the bytes of a machine word are stored in memory may vary from architecture to architecture. xe2x80x9cBig Endianxe2x80x9d architectures cause data words to be written to memory starting with the most significant byte and ending with the least significant byte. By contrast, xe2x80x9cLittle Endianxe2x80x9d architectures cause data words to be written to memory in the opposite order (i.e., from least significant byte to most significant byte). Thus, if the memory architecture of the host system stores data words in a manner opposite to that of target system memory, then the execution of native host byte stream operations (e.g., processing keyboard buffer byte streams) may not, by itself, properly emulate the byte stream operations of a corresponding target application.
The most natural solution to this problem, which has been implemented in a variety of prior emulation environments, is to perform byte-reversal techniques on byte streams of data prior to processing such streams. Byte reversal techniques are well known in the art. See, e.g., U.S. Pat. No. 5,970,236. By reversing the order of bytes prior to processing byte streams, the format of data used by applications run on a host are made to mimic that of data expected by target applications.
The emulation of target I/O (i.e., disk, peripheral storage medium) often involves complications similar to those described above. For example, emulation of the target environment may typically involve emulation of the target disk controller including its output to, and input from, storage media. However, as with memory architectures, it is not unusual for the target disk controllers to write data bytes in one order, while the native host controller writes data in another, opposite byte order. In that event, to strictly emulate the write-to-disk operation of the target controller, the emulator system must again xe2x80x9cbyte reversexe2x80x9d data prior to disk write operations to mimic the format of disk data produced in the target environment.
Unfortunately, such byte-reversal techniques are computationally expensive and time consuming. When used in conjunction with fundamental, frequently encountered operations such as disk read and write, processing is slowed significantly as a result.
A natural solution to this problem lies in enhancing the efficiency of existing byte-reversal techniques. Byte reversal hardware implementations, providing significantly faster processing time relative to software implementations, do already exist in the art. See U.S. Pat. No. 5,970,236. Nevertheless, even such hardware implementations of byte reversing significantly slow processing if performed repeatedly. Accordingly, there is a need for more efficient peripheral, I/O operation in emulation computing environments.
The present invention is based on the observation that strict emulation of each target component on the host does not always result in an optimal emulation package. More specifically, the present invention addresses the need for more efficient I/O in emulation computing environments by providing an emulator which executes the applications of a target system on a host system, without completely emulating operation of the target peripheral, storage media controller. For example, it might be the case that the target storage media controller reads/writes data bytes to a storage medium in one order, while the native host controller reads/writes data in another order. In accordance with one embodiment of the present invention, the emulation system bypasses byte-reversal conversion prior to storage media-write operations and, accordingly, does not produce storage media having data conforming to that of target storage media.
Despite this drawback, the emulation system strikes a favorable balance between the need for precise replication of target application functionality on the one hand, and the importance of overall emulation system performance on the other. In particular, a target application project running in an emulation environment will rarely involve further use of the target system or use of storage media in the target. In fact, users who purchase emulation packages generally do so precisely to switch away from a target hardware and platform environment while maintaining the viability of existing target applications. Moreover, because storage media controllers generally read data in the same order it is written, regardless of what that order is, data in emulation system memory remains unimpaired regardless of the order of host controller read/write operations.
Accordingly, one advantage of the present invention is that it improves the efficiency and speed of I/O operations in emulation computing environments.
Another advantage of the present invention is that it simplifies the development of emulation programs where the target storage media controller writes data to storage media in a manner different than that of a host storage media controller.
Further advantages of the present invention will become apparent from the more detailed description below.